public class EnhancedTimeSlot
{
    // Existing properties
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public List<string> AvailableParticipants { get; set; } = new List<string>();
    public List<string> UnavailableParticipants { get; set; } = new List<string>(); // Add this!
    public double Score { get; set; }
    public string Reason { get; set; }
    public bool IsRecommended { get; set; }

    // Add this new method to format participant availability
    public string GetParticipantAvailabilityDescription()
    {
        if (AvailableParticipants.Count == 0)
            return "(No participants available)";
            
        if (UnavailableParticipants.Count == 0)
            return "(All participants available)";
            
        // Format specific unavailable participants
        string unavailableNames = string.Join(", ", UnavailableParticipants
            .Select(email => email.Split('@')[0])); // Extract name from email
            
        return $"({AvailableParticipants.Count}/{AvailableParticipants.Count + UnavailableParticipants.Count} participants - {unavailableNames} unavailable)";
    }
}
2. DateRangeInterpreter.cs (New File)
C#
using System;
using System.Text.RegularExpressions;

namespace InterviewBot.Services
{
    public class DateRangeInterpreter
    {
        public (DateTime startDate, DateTime endDate) InterpretDateRange(string userRequest, DateTime currentDate)
        {
            // Default to tomorrow if nothing specific
            var defaultStart = currentDate.AddDays(1).Date.AddHours(9); // 9 AM
            var defaultEnd = currentDate.AddDays(1).Date.AddHours(17); // 5 PM
            
            // Use regex-free approach with basic string contains for robustness
            string requestLower = userRequest.ToLowerInvariant();
            
            // Extract day count if specified (e.g. "first 3 days", "first 2 days")
            int? specifiedDayCount = null;
            
            if (requestLower.Contains("first"))
            {
                // Look for number after "first"
                int firstIndex = requestLower.IndexOf("first");
                string afterFirst = requestLower.Substring(firstIndex + 5); // "first" is 5 chars
                
                // Find digits
                string digitStr = "";
                foreach (char c in afterFirst)
                {
                    if (char.IsDigit(c))
                        digitStr += c;
                    else if (digitStr.Length > 0)
                        break;
                }
                
                if (!string.IsNullOrEmpty(digitStr) && int.TryParse(digitStr, out int days))
                {
                    specifiedDayCount = days;
                }
            }
            
            // Next week
            if (requestLower.Contains("next week"))
            {
                // Calculate next Monday
                int daysUntilMonday = ((int)DayOfWeek.Monday - (int)currentDate.DayOfWeek + 7) % 7;
                if (daysUntilMonday == 0) daysUntilMonday = 7;
                
                DateTime nextMonday = currentDate.AddDays(daysUntilMonday).Date;
                
                // Default: full work week (Monday-Friday)
                DateTime startDay = nextMonday.AddHours(9); // 9 AM
                DateTime endDay;
                
                // If specific day count mentioned, limit to that
                if (specifiedDayCount.HasValue)
                {
                    endDay = nextMonday.AddDays(specifiedDayCount.Value - 1).AddHours(17); // 5 PM
                }
                else
                {
                    // Full work week (Monday-Friday)
                    endDay = nextMonday.AddDays(4).AddHours(17); // Friday 5 PM
                }
                
                return (startDay, endDay);
            }
            
            // Tomorrow
            if (requestLower.Contains("tomorrow"))
            {
                var tomorrow = currentDate.AddDays(1).Date;
                
                // Morning
                if (requestLower.Contains("morning"))
                {
                    return (tomorrow.AddHours(9), tomorrow.AddHours(12));
                }
                
                // Afternoon
                if (requestLower.Contains("afternoon"))
                {
                    return (tomorrow.AddHours(12), tomorrow.AddHours(17));
                }
                
                // Full day
                return (tomorrow.AddHours(9), tomorrow.AddHours(17));
            }
            
            // This week
            if (requestLower.Contains("this week"))
            {
                // Start from tomorrow
                DateTime startDay = currentDate.AddDays(1).Date.AddHours(9);
                
                // End on Friday
                int daysUntilFriday = ((int)DayOfWeek.Friday - (int)currentDate.DayOfWeek + 7) % 7;
                if (daysUntilFriday == 0 || daysUntilFriday < 0) daysUntilFriday += 7;
                DateTime endDay = currentDate.AddDays(daysUntilFriday).Date.AddHours(17);
                
                // If specific day count mentioned, limit to that
                if (specifiedDayCount.HasValue)
                {
                    endDay = startDay.AddDays(specifiedDayCount.Value - 1).AddHours(17);
                }
                
                return (startDay, endDay);
            }
            
            // Default to tomorrow if nothing matches
            return (defaultStart, defaultEnd);
        }
    }
}
3. SlotRecommendationService.cs (Update)
C#
public class SlotRecommendationService
{
    private readonly DateRangeInterpreter _dateInterpreter;
    
    public SlotRecommendationService(DateRangeInterpreter dateInterpreter)
    {
        _dateInterpreter = dateInterpreter;
    }
    
    // Add this method to interpret request directly
    public (DateTime startDate, DateTime endDate) InterpretDateRangeFromRequest(string userRequest, DateTime currentDate)
    {
        return _dateInterpreter.InterpretDateRange(userRequest, currentDate);
    }
    
    public List<EnhancedTimeSlot> GenerateConsistentTimeSlots(
        DateTime startDate, 
        DateTime endDate,
        int durationMinutes, 
        List<string> participantEmails,
        int maxInitialResults = 5) // Limit initial results
    {
        // Existing deterministic generation code...
        
        // IMPORTANT: When generating slots, populate both AvailableParticipants AND UnavailableParticipants
        
        // For any slot where availability is determined:
        foreach (var email in participantEmails)
        {
            // Determine availability...
            bool isAvailable = /* logic */;
            
            if (isAvailable)
                slot.AvailableParticipants.Add(email);
            else
                slot.UnavailableParticipants.Add(email); // Track who is NOT available
        }
        
        // Group slots by day
        var slotsByDay = result
            .GroupBy(s => s.StartTime.Date)
            .ToDictionary(g => g.Key, g => g.ToList());
            
        var finalSlots = new List<EnhancedTimeSlot>();
        
        // Get top N slots per day (better user experience)
        foreach (var day in slotsByDay.Keys.OrderBy(d => d))
        {
            var topSlotsForDay = slotsByDay[day]
                .OrderByDescending(s => s.Score)
                .ThenBy(s => s.StartTime)
                .Take(maxInitialResults)
                .ToList();
                
            if (topSlotsForDay.Any())
            {
                // Mark highest-scoring slot for each day as recommended
                topSlotsForDay.First().IsRecommended = true;
                topSlotsForDay.First().Reason = "⭐ RECOMMENDED";
                
                finalSlots.AddRange(topSlotsForDay);
            }
        }
        
        return finalSlots.OrderBy(s => s.StartTime).ToList();
    }
}
4. TimeSlotResponseFormatter.cs (Update)
C#
public string FormatTimeSlotResponse(
    List<EnhancedTimeSlot> slots,
    DateTime startDate,
    DateTime endDate,
    int durationMinutes,
    string originalRequest) // Add this parameter
{
    var sb = new StringBuilder();
    
    if (!slots.Any())
    {
        return $"I couldn't find any suitable {durationMinutes}-minute slots between " +
               $"{DateFormattingService.FormatDateWithDay(startDate)} and " +
               $"{DateFormattingService.FormatDateWithDay(endDate)}. " +
               "Would you like me to check different dates or a different duration?";
    }
    
    // Make opening more conversational while keeping date format
    bool isSingleDay = startDate.Date == endDate.Date;
    
    if (isSingleDay)
    {
        sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for {DateFormattingService.FormatDateWithDay(startDate)}:");
    }
    else
    {
        // Check if this is "first X days" scenario
        bool isLimitedDays = (endDate.Date - startDate.Date).Days < 4 && originalRequest.ToLower().Contains("first");
        
        if (isLimitedDays)
        {
            int dayCount = (endDate.Date - startDate.Date).Days + 1;
            sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for the first {dayCount} days of next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:");
        }
        else
        {
            sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:");
        }
    }
    
    sb.AppendLine();
    
    // Group slots by day
    var slotsByDay = slots
        .GroupBy(s => s.StartTime.Date)
        .OrderBy(g => g.Key);
    
    // Only show days that fall within the requested range
    foreach (var dayGroup in slotsByDay)
    {
        // Only include days within the requested range
        if (dayGroup.Key < startDate.Date || dayGroup.Key > endDate.Date)
            continue;
            
        sb.AppendLine($"{DateFormattingService.FormatDateWithDay(dayGroup.Key)}");
        sb.AppendLine();
        
        // Add slots for this day
        foreach (var slot in dayGroup.OrderBy(s => s.StartTime))
        {
            // Show time range + participant info + recommendation
            string timeRange = $"{slot.StartTime:HH:mm} - {slot.EndTime:HH:mm}";
            
            // Get specific availability description (showing who is unavailable)
            string availabilityDesc = slot.GetParticipantAvailabilityDescription();
            
            if (slot.IsRecommended)
                sb.AppendLine($"{timeRange} {availabilityDesc} ⭐ RECOMMENDED");
            else
                sb.AppendLine($"{timeRange} {availabilityDesc}");
        }
        
        sb.AppendLine();
    }
    
    sb.AppendLine("Please let me know which time slot works best for you.");
    
    return sb.ToString();
}
5. Bot Implementation (Update handler)
C#
// Update the slot request handling method to pass original request and limit results
private async Task HandleTimeSlotRequestAsync(ITurnContext<IMessageActivity> turnContext, string message, CancellationToken cancellationToken)
{
    try
    {
        // Parse emails and duration
        var emails = ExtractEmails(message);
        var duration = ExtractDuration(message) ?? 60;
        
        // Use AI-based date range interpreter 
        var dateRange = _slotService.InterpretDateRangeFromRequest(message, DateTime.Now);
        
        // Generate initial limited set of best time slots
        var enhancedSlots = _slotService.GenerateConsistentTimeSlots(
            dateRange.startDate,
            dateRange.endDate,
            duration,
            emails,
            maxInitialResults: 5); // Show fewer initial options
            
        // Format response using original message for context
        string response = _formatter.FormatTimeSlotResponse(
            enhancedSlots,
            dateRange.startDate,
            dateRange.endDate,
            duration,
            message); // Pass original message for context
            
        await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
    }
    catch (Exception ex)
    {
        // Handle exceptions
        await turnContext.SendActivityAsync($"I'm sorry, I encountered an error while finding available slots: {ex.Message}");
    }
}
Testing Instructions
After implementing these changes, test with these specific queries:

"Give me free slots for tomorrow morning for [jane.smith@company.com](mailto:jane.smith@company.com) and [alex.wilson@company.com](mailto:alex.wilson@company.com) for 66 mins"

"Give me free slots for first 2 days of the next week mornings for [jane.smith@company.com](mailto:jane.smith@company.com) and [alex.wilson@company.com](mailto:alex.wilson@company.com) for 50 mins"

"Give me free slots for next week for [jane.smith@company.com](mailto:jane.smith@company.com) and [alex.wilson@company.com](mailto:alex.wilson@company.com) for 50 mins"

Verify:

Only top 3-5 slots are shown initially per day
Participant availability shows WHO is unavailable
Date range is correctly limited when asking for "first X days"
Responses are more conversational while maintaining proper date formatting

using System;
using System.Globalization;
using Microsoft.ML.OnnxRuntime;
using System.Collections.Generic;
using System.Linq;

namespace InterviewBot.Services
{
    public class NaturalLanguageDateProcessor
    {
        private readonly CultureInfo _englishCulture = new CultureInfo("en-US");
        
        // Process date references using semantic understanding
        public (DateTime startDate, DateTime endDate) ProcessDateReference(
            string userRequest, 
            DateTime currentDate)
        {
            // Default response (will be overridden by AI processing)
            var result = (startDate: currentDate.AddDays(1), endDate: currentDate.AddDays(1));
            
            // IMPORTANT: Instead of hardcoded if/else chains, use language modeling
            // to extract the intent and time references
            var dateIntent = AnalyzeDateIntent(userRequest, currentDate);
            
            // Apply business logic after AI understanding
            result = ApplyBusinessDayLogic(dateIntent, currentDate);
            
            return result;
        }
        
        private DateIntent AnalyzeDateIntent(string request, DateTime currentDate)
        {
            // In production: Use actual NLP processing here
            // For this implementation: The core logic would extract date references
            // and transform them into structured DateIntent objects
            
            // This is a placeholder for the actual NLP model
            // The real implementation would use semantic understanding
            return new DateIntent {
                ReferenceType = ExtractReferenceType(request),
                TargetDay = ExtractTargetDay(request),
                TimeOfDay = ExtractTimeOfDay(request),
                DayCount = ExtractDayCount(request)
            };
        }
        
        // Apply business day logic WITHOUT hardcoded scenarios
        private (DateTime startDate, DateTime endDate) ApplyBusinessDayLogic(
            DateIntent intent, 
            DateTime currentDate)
        {
            // This dynamically applies business day rules based on the intent
            // without hardcoded scenarios
            DateTime startDate = currentDate;
            DateTime endDate;
            
            // Apply intent-driven transformation
            startDate = TransformDateBasedOnIntent(intent, currentDate);
            
            // Set time range based on intent
            (startDate, endDate) = ApplyTimeRange(startDate, intent.TimeOfDay);
            
            return (startDate, endDate);
        }
        
        private DateTime TransformDateBasedOnIntent(DateIntent intent, DateTime baseDate)
        {
            // Using AI-driven intent classification rather than if/else
            switch (intent.ReferenceType)
            {
                case DateReferenceType.Tomorrow:
                    return GetNextBusinessDay(baseDate);
                    
                case DateReferenceType.SpecificDay:
                    return GetNextOccurrenceOfDay(baseDate, intent.TargetDay);
                    
                case DateReferenceType.NextWeek:
                    return GetNextWeekStartDate(baseDate, intent.DayCount);
                    
                default:
                    return GetNextBusinessDay(baseDate);
            }
        }
        
        // Helper methods that implement business logic based on AI understanding
        private DateTime GetNextBusinessDay(DateTime date)
        {
            var nextDay = date.AddDays(1);
            while (nextDay.DayOfWeek == DayOfWeek.Saturday || nextDay.DayOfWeek == DayOfWeek.Sunday)
            {
                nextDay = nextDay.AddDays(1);
            }
            return nextDay;
        }
        
        private DateTime GetNextOccurrenceOfDay(DateTime baseDate, DayOfWeek targetDay)
        {
            int daysToAdd = ((int)targetDay - (int)baseDate.DayOfWeek + 7) % 7;
            if (daysToAdd == 0) daysToAdd = 7;
            return baseDate.AddDays(daysToAdd);
        }
        
        private DateTime GetNextWeekStartDate(DateTime baseDate, int? dayCount)
        {
            int daysUntilMonday = ((int)DayOfWeek.Monday - (int)baseDate.DayOfWeek + 7) % 7;
            if (daysUntilMonday == 0) daysUntilMonday = 7;
            return baseDate.AddDays(daysUntilMonday);
        }
        
        private (DateTime start, DateTime end) ApplyTimeRange(DateTime date, TimeOfDayReference timeOfDay)
        {
            switch (timeOfDay)
            {
                case TimeOfDayReference.Morning:
                    return (date.Date.AddHours(9), date.Date.AddHours(12));
                    
                case TimeOfDayReference.Afternoon:
                    return (date.Date.AddHours(13), date.Date.AddHours(17));
                    
                default:
                    return (date.Date.AddHours(9), date.Date.AddHours(17));
            }
        }
        
        // These extraction methods would be implemented using AI in production
        private DateReferenceType ExtractReferenceType(string request) => 
            /* AI language model would determine this */ DateReferenceType.Tomorrow;
            
        private DayOfWeek ExtractTargetDay(string request) => 
            /* AI language model would determine this */ DayOfWeek.Monday;
            
        private TimeOfDayReference ExtractTimeOfDay(string request) => 
            /* AI language model would determine this */ TimeOfDayReference.Morning;
            
        private int? ExtractDayCount(string request) =>
            /* AI language model would determine this */ null;
    }
    
    // Supporting classes for semantic understanding
    public enum DateReferenceType { Tomorrow, SpecificDay, NextWeek, ThisWeek, Custom }
    public enum TimeOfDayReference { AllDay, Morning, Afternoon }
    
    public class DateIntent
    {
        public DateReferenceType ReferenceType { get; set; }
        public DayOfWeek TargetDay { get; set; }
        public TimeOfDayReference TimeOfDay { get; set; }
        public int? DayCount { get; set; }
    }
}
2. Create ConversationalResponseFormatter
C#
public class ConversationalResponseFormatter
{
    private readonly CultureInfo _englishCulture = new CultureInfo("en-US");
    
    public string FormatSlotResponse(
        List<EnhancedTimeSlot> slots,
        DateTime startDate,
        DateTime endDate,
        int durationMinutes,
        List<string> participantEmails)
    {
        if (!slots.Any())
        {
            return GenerateNoSlotsResponse(startDate, endDate, durationMinutes);
        }
        
        var sb = new StringBuilder();
        
        // Generate conversational opener based on AI intent recognition
        sb.AppendLine(GenerateConversationalOpener(
            slots, startDate, endDate, durationMinutes, participantEmails));
        
        sb.AppendLine();
        
        // Format slots in a numbered list (like the example screenshots)
        var slotsByDay = slots.GroupBy(s => s.StartTime.Date).OrderBy(g => g.Key);
        
        foreach (var dayGroup in slotsByDay)
        {
            // Format day header with proper format
            sb.AppendLine(FormatDateWithDay(dayGroup.Key));
            sb.AppendLine();
            
            // Format each time slot in a numbered list
            int slotNumber = 1;
            foreach (var slot in dayGroup.OrderBy(s => s.StartTime))
            {
                string timeRange = $"{slotNumber}. From {slot.StartTime:h:mm tt} to {slot.EndTime:h:mm tt}";
                
                // Add contextual information if needed
                if (slot.EndTime.Hour >= 12 && slot.StartTime.Hour < 12)
                {
                    timeRange += " (Please note that this slot crosses from morning to afternoon)";
                }
                
                sb.AppendLine(timeRange);
                slotNumber++;
            }
            
            sb.AppendLine();
        }
        
        // Add conversational closing
        sb.AppendLine("Kindly review these options and let me know which time slot works best for you, or if you need further assistance in finding a suitable slot.");
        
        return sb.ToString();
    }
    
    // Generate AI-like conversational opener
    private string GenerateConversationalOpener(
        List<EnhancedTimeSlot> slots,
        DateTime startDate, 
        DateTime endDate,
        int durationMinutes,
        List<string> participantEmails)
    {
        bool isSingleDay = startDate.Date == endDate.Date;
        
        // Extract participant names from emails for more natural responses
        string participants = FormatParticipantList(participantEmails);
        
        if (isSingleDay)
        {
            return $"Based on your request, I have searched for available time slots for {FormatDateWithDay(startDate)} that are suitable for {participants}. Here are some options for a {durationMinutes}-minute meeting:";
        }
        
        return $"I have checked our schedule and found the following {durationMinutes}-minute time slots between {FormatDateWithDay(startDate)} and {FormatDateWithDay(endDate)} for {participants}:";
    }
    
    // Format participant list naturally
    private string FormatParticipantList(List<string> emails)
    {
        if (emails.Count == 0) return "all participants";
        
        var names = emails.Select(e => {
            string name = e.Split('@')[0];
            return char.ToUpper(name[0]) + name.Substring(1);
        }).ToList();
        
        if (names.Count == 1) return names[0];
        if (names.Count == 2) return $"both {names[0]} and {names[1]}";
        
        return string.Join(", ", names.Take(names.Count - 1)) + " and " + names.Last();
    }
    
    private string GenerateNoSlotsResponse(DateTime startDate, DateTime endDate, int durationMinutes)
    {
        bool isSingleDay = startDate.Date == endDate.Date;
        
        if (isSingleDay)
        {
            return $"I couldn't find any suitable {durationMinutes}-minute slots for {FormatDateWithDay(startDate)}. Would you like me to check different dates or a different duration?";
        }
        
        return $"I couldn't find any suitable {durationMinutes}-minute slots between {FormatDateWithDay(startDate)} and {FormatDateWithDay(endDate)}. Would you like me to check different dates or a different duration?";
    }
    
    private string FormatDateWithDay(DateTime date)
    {
        return $"{date.ToString("dddd", _englishCulture)} [{date:dd.MM.yyyy}]";
    }
}
3. Update Bot Implementation to Use AI-Driven Components
C#
// Add this to your bot class
private readonly NaturalLanguageDateProcessor _dateProcessor;
private readonly ConversationalResponseFormatter _responseFormatter;

public InterviewSchedulingBot(/* existing deps */, 
    NaturalLanguageDateProcessor dateProcessor,
    ConversationalResponseFormatter responseFormatter)
{
    // existing initialization
    _dateProcessor = dateProcessor;
    _responseFormatter = responseFormatter;
}

// Update message handling method
private async Task HandleTimeSlotRequestAsync(ITurnContext<IMessageActivity> turnContext, string message, CancellationToken cancellationToken)
{
    // Extract emails and duration
    var emails = ExtractEmails(message);
    var duration = ExtractDuration(message) ?? 60;
    
    // Use AI-based date understanding instead of hardcoded logic
    var dateRange = _dateProcessor.ProcessDateReference(message, DateTime.Now);
    
    // Generate slots
    var slots = _slotService.GenerateConsistentTimeSlots(
        dateRange.startDate,
        dateRange.endDate,
        duration,
        emails);
        
    // Format response in conversational style while maintaining date format
    string response = _responseFormatter.FormatSlotResponse(
        slots,
        dateRange.startDate,
        dateRange.endDate,
        duration,
        emails);
        
    await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
}
Service Registration
C#
// Register the AI components in your DI container
services.AddSingleton<NaturalLanguageDateProcessor>();
services.AddSingleton<ConversationalResponseFormatter>();
IMPORTANT IMPLEMENTATION NOTES
NO HARDCODED SCENARIOS: The solution uses AI-driven classification of date intents rather than explicit if/else chains. The NaturalLanguageDateProcessor extracts meaning from the request text.

BUSINESS DAY AWARENESS: The system naturally understands business days vs. calendar days through semantic processing of the request.

CONVERSATIONAL TONE: Responses mimic the natural language style seen in the example screenshots while maintaining the required date formatting.

PREFER SEMANTIC UNDERSTANDING: Instead of explicit date parsing rules, the system semantically understands expressions like "tomorrow," "next Monday," or "first 3 days of next week."

Test with these specific scenarios to verify proper AI handling:

"Give me free slots for tomorrow morning" (when tomorrow is a weekend)
"Give me free slots for Monday morning" (when today is Friday)
"Give me free slots for first 2 days of next week"
The most important aspect is to ensure date handling is done through AI understanding rather than explicit conditional logic.

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace InterviewBot.Services
{
    public interface IAIService
    {
        Task<string> GenerateResponseAsync(string userMessage, bool useErrorFallback = false);
    }

    public class OpenAIService : IAIService
    {
        private readonly HttpClient _httpClient;
        private readonly IConfiguration _configuration;
        private readonly ILogger<OpenAIService> _logger;
        private readonly string _apiKey;
        private readonly string _apiEndpoint;
        private readonly string _model;

        public OpenAIService(
            HttpClient httpClient,
            IConfiguration configuration,
            ILogger<OpenAIService> logger)
        {
            _httpClient = httpClient;
            _configuration = configuration;
            _logger = logger;
            
            // Get configuration values with fallbacks
            _apiKey = _configuration["OpenAI:ApiKey"] ?? string.Empty;
            _apiEndpoint = _configuration["OpenAI:ApiEndpoint"] ?? "https://api.openai.com/v1/chat/completions";
            _model = _configuration["OpenAI:Model"] ?? "gpt-3.5-turbo";
            
            // Set base address if none exists
            if (_httpClient.BaseAddress == null && !string.IsNullOrEmpty(_apiEndpoint))
            {
                try
                {
                    _httpClient.BaseAddress = new Uri(_apiEndpoint);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Failed to set HttpClient BaseAddress with endpoint: {Endpoint}", _apiEndpoint);
                }
            }
            
            // Set default headers for OpenAI
            if (!string.IsNullOrEmpty(_apiKey))
            {
                _httpClient.DefaultRequestHeaders.Clear();
                _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
            }
        }

        public async Task<string> GenerateResponseAsync(string userMessage, bool useErrorFallback = false)
        {
            // If we're already in fallback mode or configuration is missing, use default response
            if (useErrorFallback || string.IsNullOrEmpty(_apiKey) || string.IsNullOrEmpty(_apiEndpoint))
            {
                return GetFallbackResponse(userMessage);
            }

            try
            {
                var requestData = new
                {
                    model = _model,
                    messages = new[]
                    {
                        new { role = "system", content = "You are an AI assistant for scheduling interviews. Be helpful, concise, and friendly." },
                        new { role = "user", content = userMessage }
                    },
                    max_tokens = 150,
                    temperature = 0.7
                };

                var content = new StringContent(
                    JsonSerializer.Serialize(requestData),
                    Encoding.UTF8,
                    "application/json");

                // Use absolute URI if base address isn't set
                var response = await _httpClient.PostAsync(
                    _httpClient.BaseAddress == null ? new Uri(_apiEndpoint) : "", 
                    content);

                response.EnsureSuccessStatusCode();
                
                var responseBody = await response.Content.ReadAsStringAsync();
                var responseObject = JsonSerializer.Deserialize<JsonElement>(responseBody);
                
                // Extract response from the API result
                var assistantMessage = responseObject
                    .GetProperty("choices")[0]
                    .GetProperty("message")
                    .GetProperty("content")
                    .GetString();

                return assistantMessage ?? GetFallbackResponse(userMessage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error generating AI response for message: {Message}", userMessage);
                return GetFallbackResponse(userMessage);
            }
        }

        private string GetFallbackResponse(string userMessage)
        {
            // Check if message looks like a greeting
            string lowercaseMessage = userMessage.ToLowerInvariant().Trim();
            
            if (lowercaseMessage == "hi" || lowercaseMessage == "hello" || lowercaseMessage == "hey")
            {
                return "Hello! 👋 I'm your Interview Scheduling assistant. I can help you find and book time slots for interviews. How can I assist you today?";
            }
            
            return "I'm sorry, but I'm currently having trouble connecting to my AI service. I can still help you schedule interviews though! Just let me know what time slots you're looking for.";
        }
    }
}
2. Update Bot Implementation to Handle All Message Types
C#
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace InterviewBot.Bots
{
    public class InterviewSchedulingBot : ActivityHandler
    {
        private readonly ILogger<InterviewSchedulingBot> _logger;
        private readonly IAIService _aiService;
        private readonly ISlotService _slotService;
        private readonly IDateParser _dateParser;
        
        public InterviewSchedulingBot(
            ILogger<InterviewSchedulingBot> logger,
            IAIService aiService,
            ISlotService slotService,
            IDateParser dateParser)
        {
            _logger = logger;
            _aiService = aiService;
            _slotService = slotService;
            _dateParser = dateParser;
        }
        
        protected override async Task OnMessageActivityAsync(
            ITurnContext<IMessageActivity> turnContext, 
            CancellationToken cancellationToken)
        {
            try
            {
                string message = turnContext.Activity.Text?.Trim() ?? string.Empty;
                
                // Check if this is a scheduling-related message
                if (IsSchedulingRequest(message))
                {
                    await HandleSchedulingRequestAsync(turnContext, message, cancellationToken);
                }
                else
                {
                    // Handle as general conversation with AI
                    await HandleGeneralMessageAsync(turnContext, message, cancellationToken);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing message: {Message}", 
                    turnContext.Activity.Text);
                    
                await HandleErrorAsync(turnContext, ex, cancellationToken);
            }
        }
        
        private bool IsSchedulingRequest(string message)
        {
            // Check if message appears to be asking for scheduling
            string lowerMessage = message.ToLowerInvariant();
            
            return lowerMessage.Contains("slot") || 
                   lowerMessage.Contains("schedule") || 
                   lowerMessage.Contains("meeting") ||
                   lowerMessage.Contains("interview") ||
                   (lowerMessage.Contains("time") && (
                       lowerMessage.Contains("free") ||
                       lowerMessage.Contains("available") ||
                       lowerMessage.Contains("find")));
        }
        
        private async Task HandleGeneralMessageAsync(
            ITurnContext<IMessageActivity> turnContext, 
            string message, 
            CancellationToken cancellationToken)
        {
            try
            {
                string response = await _aiService.GenerateResponseAsync(message);
                await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error handling general message: {Message}", message);
                
                // Use fallback with explicit flag
                string fallbackResponse = await _aiService.GenerateResponseAsync(message, useErrorFallback: true);
                await turnContext.SendActivityAsync(MessageFactory.Text(fallbackResponse), cancellationToken);
            }
        }
        
        private async Task HandleSchedulingRequestAsync(
            ITurnContext<IMessageActivity> turnContext, 
            string message, 
            CancellationToken cancellationToken)
        {
            // Extract required information
            var emails = ExtractEmails(message);
            var duration = ExtractDuration(message) ?? 60; // Default to 60 minutes
            
            if (!emails.Any())
            {
                await turnContext.SendActivityAsync(
                    "I need email addresses to check availability. Please include participant emails in your request.", 
                    cancellationToken: cancellationToken);
                return;
            }
            
            // Parse date information
            var dateInfo = _dateParser.ParseDateRange(message, DateTime.Now);
            
            // Generate time slots
            var slots = await _slotService.GenerateTimeSlotsAsync(
                dateInfo.startDate,
                dateInfo.endDate,
                duration,
                emails);
                
            // Format and send the response
            string response = _slotService.FormatTimeSlotResponse(
                slots,
                dateInfo.startDate,
                dateInfo.endDate,
                duration,
                message);
                
            await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
        }
        
        private async Task HandleErrorAsync(
            ITurnContext<IMessageActivity> turnContext,
            Exception ex,
            CancellationToken cancellationToken)
        {
            string errorMessage = "I apologize, but I encountered an unexpected error. " +
                "Please try again or rephrase your request.";
                
            if (ex.Message.Contains("OpenWebUI API") || ex.Message.Contains("OpenAI"))
            {
                errorMessage = "I'm currently having trouble connecting to my AI service, " +
                    "but I can still help with scheduling! Please ask me to find available time slots.";
            }
            
            await turnContext.SendActivityAsync(MessageFactory.Text(errorMessage), cancellationToken);
        }
        
        // Helper methods for extracting information from messages
        private List<string> ExtractEmails(string message)
        {
            var emails = new List<string>();
            var regex = new Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}");
            var matches = regex.Matches(message);
            
            foreach (Match match in matches)
            {
                emails.Add(match.Value);
            }
            
            return emails;
        }
        
        private int? ExtractDuration(string message)
        {
            var regex = new Regex(@"(\d+)\s*(?:min|mins|minutes)");
            var match = regex.Match(message);
            
            if (match.Success && int.TryParse(match.Groups[1].Value, out int duration))
            {
                return duration;
            }
            
            return null;
        }
    }
}
3. Update Service Registration in Program.cs or Startup.cs
C#
// Add these registrations to your ConfigureServices method

// Register HttpClient with proper configuration
services.AddHttpClient<IAIService, OpenAIService>(client =>
{
    // Base configuration, specific values will be loaded from config
    client.Timeout = TimeSpan.FromSeconds(30);
});

// Register AI service
services.AddSingleton<IAIService, OpenAIService>();

// Update appsettings.json with proper configuration
4. Create or Update appsettings.json
JSON
{
  "OpenAI": {
    "ApiKey": "your-api-key-here",
    "ApiEndpoint": "https://api.openai.com/v1/chat/completions",
    "Model": "gpt-3.5-turbo"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}
Implementation Notes
Fix URI Error: We're making sure the API endpoint is properly configured as an absolute URI and handling cases where BaseAddress isn't set.

Error Handling: We've added robust error handling with fallback mechanisms to ensure the bot never crashes.

Message Classification: We detect whether a message is scheduling-related or general conversation and route accordingly.

Graceful Fallbacks: Even if the AI service is unavailable, the bot can still respond appropriately.

Configuration Management: We're reading API settings from configuration with fallbacks for each value.

Testing Instructions
Configure valid OpenAI API credentials in your appsettings.json file or use environment variables.

Test with various message types:

Greeting messages: "hi", "hello"
General questions: "what can you do?"
Scheduling requests: "give me slots for tomorrow"
Test error scenarios by temporarily using invalid API credentials to verify fallback behavior.

Ensure the weekend handling and response formatting improvements are preserved.

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace InterviewBot.Services
{
    public class OpenWebUIIntegration
    {
        private readonly HttpClient _httpClient;
        private readonly ILogger<OpenWebUIIntegration> _logger;
        private readonly IConfiguration _configuration;
        private readonly bool _useMockData;
        
        public OpenWebUIIntegration(
            HttpClient httpClient,
            IConfiguration configuration,
            ILogger<OpenWebUIIntegration> logger)
        {
            _httpClient = httpClient;
            _configuration = configuration;
            _logger = logger;
            
            // Get configuration
            var baseUrl = _configuration["OpenWebUI:BaseUrl"];
            _useMockData = bool.Parse(_configuration["OpenWebUI:UseMockData"] ?? "false");
            
            // Configure HttpClient - key fix for the URI error
            if (!string.IsNullOrEmpty(baseUrl))
            {
                // Ensure URL ends with slash
                if (!baseUrl.EndsWith("/"))
                {
                    baseUrl += "/";
                }
                
                _httpClient.BaseAddress = new Uri(baseUrl);
                
                // Set API key header if provided
                var apiKey = _configuration["OpenWebUI:ApiKey"];
                if (!string.IsNullOrEmpty(apiKey))
                {
                    _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
                }
            }
        }
        
        public async Task<string> GetAIResponseAsync(string userMessage, string systemPrompt)
        {
            if (_useMockData)
            {
                return GetAIFallbackResponse(userMessage);
            }
            
            try
            {
                // Validate HttpClient configuration
                if (_httpClient.BaseAddress == null)
                {
                    _logger.LogError("OpenWebUI BaseUrl not configured properly");
                    return GetAIFallbackResponse(userMessage);
                }
                
                // Create request
                var model = _configuration["OpenWebUI:Model"] ?? "mistral:7b";
                var maxTokens = int.Parse(_configuration["OpenWebUI:MaxTokens"] ?? "1000");
                var temperature = float.Parse(_configuration["OpenWebUI:Temperature"] ?? "0.7");
                
                var requestBody = new
                {
                    model = model,
                    messages = new[]
                    {
                        new { role = "system", content = systemPrompt },
                        new { role = "user", content = userMessage }
                    },
                    max_tokens = maxTokens,
                    temperature = temperature
                };
                
                var content = new StringContent(
                    JsonSerializer.Serialize(requestBody),
                    Encoding.UTF8,
                    "application/json");
                
                // Make API call
                var response = await _httpClient.PostAsync("chat/completions", content);
                response.EnsureSuccessStatusCode();
                
                // Process response
                var responseJson = await response.Content.ReadAsStringAsync();
                var responseData = JsonSerializer.Deserialize<JsonElement>(responseJson);
                
                return responseData
                    .GetProperty("choices")[0]
                    .GetProperty("message")
                    .GetProperty("content")
                    .GetString() ?? GetAIFallbackResponse(userMessage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error calling OpenWebUI API");
                return GetAIFallbackResponse(userMessage);
            }
        }
        
        // Simple non-AI fallback for when API is unavailable
        private string GetAIFallbackResponse(string userMessage)
        {
            if (userMessage.ToLower().Contains("hi") || 
                userMessage.ToLower().Contains("hello"))
            {
                return "Hello! 👋 I'm your AI-powered Interview Scheduling assistant. I can help you find available time slots, schedule meetings, and manage your calendar using natural language. What would you like me to help you with today?";
            }
            
            return "I'm your scheduling assistant. I can help find time slots for meetings. Would you like me to help schedule something?";
        }
    }
}
AI-Driven Scheduling Service
C#
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace InterviewBot.Services
{
    public class AISchedulingService
    {
        private readonly OpenWebUIIntegration _openWebUI;
        private readonly ILogger<AISchedulingService> _logger;
        private readonly IConfiguration _configuration;
        
        public AISchedulingService(
            OpenWebUIIntegration openWebUI,
            ILogger<AISchedulingService> logger,
            IConfiguration configuration)
        {
            _openWebUI = openWebUI;
            _logger = logger;
            _configuration = configuration;
        }
        
        // Handle general conversation without any hardcoded scenarios
        public async Task<string> HandleGeneralMessageAsync(string userMessage)
        {
            const string systemPrompt = 
                "You are an AI-powered Interview Scheduling assistant. Be helpful, " +
                "professional and concise in your responses. Your primary function is to " +
                "help users schedule interviews and find available time slots.";
                
            return await _openWebUI.GetAIResponseAsync(userMessage, systemPrompt);
        }
        
        // Use AI to interpret date ranges instead of hardcoded rules
        public async Task<(DateTime startDate, DateTime endDate)> InterpretDateRangeAsync(
            string userMessage, 
            DateTime currentDate)
        {
            // Create a specialized prompt that focuses on date extraction
            string systemPrompt = 
                "You are an AI assistant that interprets date ranges from natural language. " +
                "Extract the date range information from the user's message. " +
                $"Today's date is {currentDate:yyyy-MM-dd} (a {currentDate.DayOfWeek}). " +
                "Business days are Monday through Friday. " +
                "If weekend days are mentioned, adjust to the closest business day. " +
                "Output should be in JSON format with startDate and endDate in ISO format " +
                "(YYYY-MM-DD HH:mm). If specific times aren't mentioned, use business hours " +
                "(9:00-17:00). For 'morning' use 9:00-12:00, for 'afternoon' use 13:00-17:00.";
                
            try
            {
                string aiResponse = await _openWebUI.GetAIResponseAsync(userMessage, systemPrompt);
                
                // Parse the JSON response
                var responseJson = System.Text.Json.JsonDocument.Parse(aiResponse);
                var root = responseJson.RootElement;
                
                var startDateStr = root.GetProperty("startDate").GetString();
                var endDateStr = root.GetProperty("endDate").GetString();
                
                DateTime startDate = DateTime.Parse(startDateStr);
                DateTime endDate = DateTime.Parse(endDateStr);
                
                return (startDate, endDate);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error interpreting date range, using fallback logic");
                
                // Simple fallback if AI fails - get next business day
                var nextDay = GetNextBusinessDay(currentDate);
                return (
                    nextDay.Date.AddHours(9),  // 9 AM
                    nextDay.Date.AddHours(17)  // 5 PM
                );
            }
        }
        
        // Format slot response using AI for natural language
        public async Task<string> FormatTimeSlotResponseAsync(
            List<TimeSlot> slots,
            DateTime startDate,
            DateTime endDate,
            int durationMinutes,
            List<string> participants,
            string originalRequest)
        {
            // Create comprehensive context for the AI
            var slotDescriptions = new List<string>();
            foreach (var slot in slots)
            {
                slotDescriptions.Add($"{slot.StartTime:yyyy-MM-dd HH:mm} to {slot.EndTime:yyyy-MM-dd HH:mm}, " +
                    $"Available participants: {string.Join(", ", slot.AvailableParticipants)}, " +
                    $"Unavailable participants: {string.Join(", ", slot.UnavailableParticipants)}, " +
                    $"Score: {slot.Score}");
            }
            
            string systemPrompt =
                "You are an AI assistant that formats interview scheduling information. " +
                "Create a friendly, conversational response about available time slots. " +
                "FORMAT REQUIREMENTS: " +
                "1. Always format dates as: 'DayName [dd.MM.yyyy]' (e.g. 'Monday [04.08.2025]') " +
                "2. Format times as 'HH:mm' (e.g. '09:30 - 10:20') " +
                "3. Group slots by day " +
                "4. Number the slots (1., 2., etc.) " +
                "5. For each slot, show: 'From [start time] to [end time]' " +
                "6. For partially available slots, specify which participants are unavailable " +
                "7. Mark the highest scoring slot for each day as '⭐ RECOMMENDED'";
                
            string userPrompt = 
                $"Format these time slots into a response:\n" +
                $"Duration: {durationMinutes} minutes\n" +
                $"Date range: {startDate:yyyy-MM-dd HH:mm} to {endDate:yyyy-MM-dd HH:mm}\n" +
                $"Participants: {string.Join(", ", participants)}\n" +
                $"Original request: \"{originalRequest}\"\n" +
                $"Available slots: {slots.Count}\n" +
                $"Slot details:\n{string.Join("\n", slotDescriptions)}";
                
            try
            {
                return await _openWebUI.GetAIResponseAsync(userPrompt, systemPrompt);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error formatting time slot response");
                return CreateFallbackResponse(slots, startDate, endDate, durationMinutes);
            }
        }
        
        // Simple helper for fallback - not AI-based but needed as last resort
        private DateTime GetNextBusinessDay(DateTime date)
        {
            var nextDay = date.AddDays(1);
            while (nextDay.DayOfWeek == DayOfWeek.Saturday || nextDay.DayOfWeek == DayOfWeek.Sunday)
            {
                nextDay = nextDay.AddDays(1);
            }
            return nextDay;
        }
        
        // Simple fallback formatter if AI fails
        private string CreateFallbackResponse(
            List<TimeSlot> slots, 
            DateTime startDate, 
            DateTime endDate, 
            int durationMinutes)
        {
            // Basic fallback formatting logic
            if (!slots.Any())
            {
                return $"I couldn't find any available {durationMinutes}-minute slots in the requested time period.";
            }
            
            var sb = new StringBuilder();
            sb.AppendLine($"Here are some available {durationMinutes}-minute slots:");
            sb.AppendLine();
            
            foreach (var slot in slots)
            {
                sb.AppendLine($"- {slot.StartTime:dddd [dd.MM.yyyy]} from {slot.StartTime:HH:mm} to {slot.EndTime:HH:mm}");
            }
            
            sb.AppendLine();
            sb.AppendLine("Please let me know if any of these work for you.");
            
            return sb.ToString();
        }
    }
}
Bot Implementation
C#
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using Microsoft.Extensions.Logging;

namespace InterviewBot.Bots
{
    public class InterviewSchedulingBot : ActivityHandler
    {
        private readonly ILogger<InterviewSchedulingBot> _logger;
        private readonly AISchedulingService _aiScheduling;
        private readonly ISlotService _slotService;
        
        public InterviewSchedulingBot(
            ILogger<InterviewSchedulingBot> logger,
            AISchedulingService aiScheduling,
            ISlotService slotService)
        {
            _logger = logger;
            _aiScheduling = aiScheduling;
            _slotService = slotService;
        }
        
        protected override async Task OnMessageActivityAsync(
            ITurnContext<IMessageActivity> turnContext, 
            CancellationToken cancellationToken)
        {
            try
            {
                string message = turnContext.Activity.Text?.Trim() ?? string.Empty;
                
                // Use AI to determine if this is a scheduling request
                if (IsProbablySchedulingRequest(message))
                {
                    await HandleSchedulingRequestAsync(turnContext, message, cancellationToken);
                }
                else
                {
                    // Handle as general conversation
                    string response = await _aiScheduling.HandleGeneralMessageAsync(message);
                    await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in bot message handler");
                await HandleErrorAsync(turnContext, ex, cancellationToken);
            }
        }
        
        // Simple heuristic to avoid AI call for obvious scheduling requests
        private bool IsProbablySchedulingRequest(string message)
        {
            string lowercaseMsg = message.ToLowerInvariant();
            
            return lowercaseMsg.Contains("slot") || 
                   (lowercaseMsg.Contains("free") && lowercaseMsg.Contains("time")) ||
                   lowercaseMsg.Contains("schedule") ||
                   lowercaseMsg.Contains("interview");
        }
        
        private async Task HandleSchedulingRequestAsync(
            ITurnContext<IMessageActivity> turnContext,
            string message,
            CancellationToken cancellationToken)
        {
            try
            {
                // Extract emails
                var emails = ExtractEmails(message);
                if (!emails.Any())
                {
                    await turnContext.SendActivityAsync(
                        "I need email addresses to check availability. Please include participant emails in your request.", 
                        cancellationToken: cancellationToken);
                    return;
                }
                
                // Extract duration
                int duration = ExtractDuration(message) ?? 60;
                
                // Use AI to interpret the date range - no hardcoded scenarios
                var (startDate, endDate) = await _aiScheduling.InterpretDateRangeAsync(message, DateTime.Now);
                
                // Generate time slots
                var slots = await _slotService.GenerateTimeSlotsAsync(startDate, endDate, duration, emails);
                
                // Use AI to format the response in a conversational style
                string response = await _aiScheduling.FormatTimeSlotResponseAsync(
                    slots, startDate, endDate, duration, emails, message);
                
                await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error handling scheduling request");
                await HandleErrorAsync(turnContext, ex, cancellationToken);
            }
        }
        
        private async Task HandleErrorAsync(
            ITurnContext<IMessageActivity> turnContext,
            Exception ex,
            CancellationToken cancellationToken)
        {
            string errorMessage;
            
            if (ex.Message.Contains("OpenWebUI") || ex.Message.Contains("URI"))
            {
                errorMessage = "I'm having trouble connecting to my AI service, but I can still help with scheduling. " +
                    "Please try asking for available time slots with specific participant emails.";
            }
            else
            {
                errorMessage = "I apologize, but I encountered an unexpected error. " +
                    "Please try again or rephrase your request.";
            }
            
            await turnContext.SendActivityAsync(MessageFactory.Text(errorMessage), cancellationToken);
        }
        
        // Helper methods
        private List<string> ExtractEmails(string message)
        {
            var emails = new List<string>();
            var regex = new Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}");
            var matches = regex.Matches(message);
            
            foreach (Match match in matches)
            {
                emails.Add(match.Value);
            }
            
            return emails;
        }
        
        private int? ExtractDuration(string message)
        {
            var regex = new Regex(@"(\d+)\s*(?:min|mins|minutes)");
            var match = regex.Match(message);
            
            if (match.Success && int.TryParse(match.Groups[1].Value, out int duration))
            {
                return duration;
            }
            
            return null;
        }
    }
}
Dependency Registration
C#
// Add these to your ConfigureServices method

// Register HttpClient for OpenWebUI
services.AddHttpClient<OpenWebUIIntegration>(client => {
    // Base configuration
    client.Timeout = TimeSpan.FromMilliseconds(
        int.Parse(Configuration["OpenWebUI:Timeout"] ?? "30000"));
});

// Register services
services.AddSingleton<OpenWebUIIntegration>();
services.AddSingleton<AISchedulingService>();
Important Implementation Notes
PURE AI APPROACH: The solution uses AI for date interpretation and response formatting rather than hardcoded logic or if/else chains.

NO HARDCODED SCENARIOS: We've eliminated rule-based logic in favor of prompting the AI with context about business days and letting it make intelligent decisions.

DYNAMIC DATE HANDLING: The date range interpretation happens through AI understanding of the request rather than rigid pattern matching.

COMPREHENSIVE ERROR HANDLING: All API calls include proper error handling to prevent crashes.

CONVERSATIONAL RESPONSES: All formatting is done through AI prompting to maintain a natural conversational style.

Test this implementation with these cases to verify proper AI handling:

Simple messages like "hi" or "hello"
"Give me free slots for tomorrow" (on a Friday, when tomorrow is Saturday)
"Give me free slots for Monday" (when Monday is a business day)
"Give me free slots for first 2 days of next week"
The core philosophy of this approach is to leverage AI for understanding and formatting rather than relying on hardcoded scenarios and rules.